About arithmetic operators
Arithmetic operators are used to perform mathematical operations on numbers. The following are the arithmetic operators in Java:
Addition (+): Adds two operands.
Subtraction (-): Subtracts the second operand from the first operand.
Multiplication (*): Multiplies two operands.
Division (/): Divides the first operand by the second operand.
Modulus (%): Returns the remainder of the division of the first operand by the second operand.
Here are some examples of how arithmetic operators are used in Java:
Java - Arithmetic Operator
int x = 10;
int y = 20;
// Add two numbers
int sum = x + y;
System.out.println(sum); // 30
// Subtract two numbers
int difference = x - y;
System.out.println(difference); // -10
// Multiply two numbers
int product = x * y;
System.out.println(product); // 200
// Divide two numbers
int quotient = x / y;
System.out.println(quotient); // 0.5
// Modulus of two numbers
int remainder = x % y;
System.out.println(remainder); // 10
The operands of an arithmetic operator can be of any primitive numeric type, such as int, float, double, long, or short. The result of an arithmetic operation is also of the same primitive numeric type as the operands.
For example, the following code is valid:
Java
int x = 10;
float y = 20.0f;
// Add two numbers
int sum = x + y; // This is valid because the result of `x + y` is an int
However, the following code is not valid:
Java
int x = 10;
float y = 20.0f;
// Add two numbers
float sum = x + y; // This is not valid because the operand `x` is an int
In this case, the compiler will give an error because the operands of the addition operator must be of the same type.
The order of operations in arithmetic expressions is as follows:
Parentheses
Exponentiation
Multiplication and division
Addition and subtraction
For example, the following expression:
Java
x + y * z - 10
is evaluated as follows:
The multiplication operation y * z is performed first.
The addition operation x + y * z is performed next.
The subtraction operation x + y * z - 10 is performed last.
The result of the expression is the value of the last operation performed.
Here are some other important points to keep in mind about arithmetic operators in Java:
Arithmetic operators are evaluated from left to right, unless parentheses are used to change the order of operations.
The operands of an arithmetic operator must be of the same type, or they must be implicitly convertible to the same type.
The result of an arithmetic operation is of the same type as the operands, or it is the promoted type of the operands.
Tutorialsbox